<html>
<head><meta charset="utf-8"><title>lazy norm const parent generics hack · t-compiler · Zulip Chat Archive</title></head>
<h2>Stream: <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/index.html">t-compiler</a></h2>
<h3>Topic: <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/lazy.20norm.20const.20parent.20generics.20hack.html">lazy norm const parent generics hack</a></h3>

<hr>

<base href="https://rust-lang.zulipchat.com">

<head><link href="https://rust-lang.github.io/zulip_archive/style.css" rel="stylesheet"></head>

<a name="203899955"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/lazy%20norm%20const%20parent%20generics%20hack/near/203899955" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/lazy.20norm.20const.20parent.20generics.20hack.html#203899955">(Jul 14 2020 at 23:17)</a>:</h4>
<p>IIRC always enabling <a href="https://github.com/rust-lang/rust/blob/2002ebacfbca288830a3c308ddc8189705c608fe/src/librustc_typeck/collect.rs#L1178-L1183">this hack</a> previously prevented the compiler from compiling itself.</p>
<p>I just tested this again and it is now possible to self host this way and most UI tests which fail are due to <a href="https://github.com/rust-lang/rust/issues/74159">#74159</a>.<br>
Do we have an example (which works on stable rn) which fundamentally requires lazy norm if we use the parent generics here?</p>



<a name="203900152"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/lazy%20norm%20const%20parent%20generics%20hack/near/203900152" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/lazy.20norm.20const.20parent.20generics.20hack.html#203900152">(Jul 14 2020 at 23:20)</a>:</h4>
<p>I forgot this existed while writing <a href="https://internals.rust-lang.org/t/stabilizing-a-const-generics-mvp/12727/3?u=lcnr">https://internals.rust-lang.org/t/stabilizing-a-const-generics-mvp/12727/3?u=lcnr</a> <span aria-label="sweat smile" class="emoji emoji-1f605" role="img" title="sweat smile">:sweat_smile:</span></p>



<a name="203925638"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/lazy%20norm%20const%20parent%20generics%20hack/near/203925638" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> eddyb <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/lazy.20norm.20const.20parent.20generics.20hack.html#203925638">(Jul 15 2020 at 07:55)</a>:</h4>
<p><span class="user-mention" data-user-id="216206">@lcnr</span> the two positions are <code>where</code> clauses and <code>impl</code> headers</p>



<a name="203925733"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/lazy%20norm%20const%20parent%20generics%20hack/near/203925733" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> eddyb <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/lazy.20norm.20const.20parent.20generics.20hack.html#203925733">(Jul 15 2020 at 07:56)</a>:</h4>
<p>just write <code>[(); 1+1]</code> in either and watch everything fall apart</p>



<a name="203925759"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/lazy%20norm%20const%20parent%20generics%20hack/near/203925759" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> eddyb <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/lazy.20norm.20const.20parent.20generics.20hack.html#203925759">(Jul 15 2020 at 07:57)</a>:</h4>
<p>e.g. a <code>T: Into&lt;[U; 1+1]&gt;</code> bound</p>



<a name="203925772"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/lazy%20norm%20const%20parent%20generics%20hack/near/203925772" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> eddyb <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/lazy.20norm.20const.20parent.20generics.20hack.html#203925772">(Jul 15 2020 at 07:57)</a>:</h4>
<p>or <code>impl From&lt;[u8; 1+1]&gt; for Foo&lt;u16&gt;</code></p>



<a name="203925832"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/lazy%20norm%20const%20parent%20generics%20hack/near/203925832" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> eddyb <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/lazy.20norm.20const.20parent.20generics.20hack.html#203925832">(Jul 15 2020 at 07:58)</a>:</h4>
<p>(<code>impl</code> headers behave as if the trait being implemented is another bound in scope, IIRC, and that's what would cause the problem)</p>



<a name="203925890"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/lazy%20norm%20const%20parent%20generics%20hack/near/203925890" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> eddyb <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/lazy.20norm.20const.20parent.20generics.20hack.html#203925890">(Jul 15 2020 at 07:59)</a>:</h4>
<p><span class="user-mention" data-user-id="216206">@lcnr</span> note that if you enable this through lazy normalization, it probably just works, or at least the important thing is eager normalization is what causes the cycle. but you probably already know that?</p>



<a name="203951726"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/lazy%20norm%20const%20parent%20generics%20hack/near/203951726" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/lazy.20norm.20const.20parent.20generics.20hack.html#203951726">(Jul 15 2020 at 13:00)</a>:</h4>
<p><span class="user-mention" data-user-id="119009">@eddyb</span> </p>
<div class="codehilite"><pre><span></span><code><span class="k">struct</span> <span class="nc">Foo</span><span class="o">&lt;</span><span class="n">T</span><span class="p">,</span><span class="w"> </span><span class="n">U</span><span class="o">&gt;</span><span class="p">(</span><span class="n">T</span><span class="p">,</span><span class="w"> </span><span class="n">U</span><span class="p">);</span><span class="w"></span>

<span class="k">impl</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="nb">From</span><span class="o">&lt;</span><span class="p">[</span><span class="kt">u8</span><span class="p">;</span><span class="w"> </span><span class="mi">1</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span><span class="p">]</span><span class="o">&gt;</span><span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="n">Foo</span><span class="o">&lt;</span><span class="n">T</span><span class="p">,</span><span class="w"> </span><span class="p">[</span><span class="kt">u8</span><span class="p">;</span><span class="w"> </span><span class="mi">1</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span><span class="p">]</span><span class="o">&gt;</span><span class="w"> </span><span class="p">{</span><span class="w"></span>
<span class="w">    </span><span class="k">fn</span> <span class="nf">from</span><span class="p">(</span><span class="n">value</span>: <span class="p">[</span><span class="kt">u8</span><span class="p">;</span><span class="w"> </span><span class="mi">1</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span><span class="p">])</span><span class="w"> </span>-&gt; <span class="nc">Foo</span><span class="o">&lt;</span><span class="n">T</span><span class="p">,</span><span class="w"> </span><span class="p">[</span><span class="kt">u8</span><span class="p">;</span><span class="w"> </span><span class="mi">1</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span><span class="p">]</span><span class="o">&gt;</span><span class="w"> </span><span class="p">{</span><span class="w"></span>
<span class="w">        </span><span class="n">todo</span><span class="o">!</span><span class="p">();</span><span class="w"></span>
<span class="w">    </span><span class="p">}</span><span class="w"></span>
<span class="p">}</span><span class="w"></span>

<span class="k">fn</span> <span class="nf">main</span><span class="p">()</span><span class="w"> </span><span class="p">{}</span><span class="w"></span>
</code></pre></div>


<p>This compiles without lazy norm and with parent generics, do you know what's going on here?</p>



<a name="203951828"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/lazy%20norm%20const%20parent%20generics%20hack/near/203951828" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> eddyb <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/lazy.20norm.20const.20parent.20generics.20hack.html#203951828">(Jul 15 2020 at 13:01)</a>:</h4>
<p><span class="user-mention" data-user-id="216206">@lcnr</span> I'd say try <code>where</code> clauses (on e.g. a <code>fn</code>) instead</p>



<a name="203951843"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/lazy%20norm%20const%20parent%20generics%20hack/near/203951843" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> eddyb <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/lazy.20norm.20const.20parent.20generics.20hack.html#203951843">(Jul 15 2020 at 13:01)</a>:</h4>
<p>we may have changed how <code>impl</code>s do that</p>



<a name="203951937"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/lazy%20norm%20const%20parent%20generics%20hack/near/203951937" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> eddyb <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/lazy.20norm.20const.20parent.20generics.20hack.html#203951937">(Jul 15 2020 at 13:02)</a>:</h4>
<p>it's also possible the "lazy normalization" toggle isn't actually what makes most stuff work, lol</p>



<a name="203951959"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/lazy%20norm%20const%20parent%20generics%20hack/near/203951959" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> eddyb <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/lazy.20norm.20const.20parent.20generics.20hack.html#203951959">(Jul 15 2020 at 13:02)</a>:</h4>
<p>e.g. <span class="user-mention" data-user-id="124288">@oli</span> may have made some stuff lazy without being behind any feature-gates</p>



<a name="203951972"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/lazy%20norm%20const%20parent%20generics%20hack/near/203951972" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/lazy.20norm.20const.20parent.20generics.20hack.html#203951972">(Jul 15 2020 at 13:02)</a>:</h4>
<p>It should be <span aria-label="laughing" class="emoji emoji-1f606" role="img" title="laughing">:laughing:</span> I implemented it myself</p>



<a name="203951992"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/lazy%20norm%20const%20parent%20generics%20hack/near/203951992" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/lazy.20norm.20const.20parent.20generics.20hack.html#203951992">(Jul 15 2020 at 13:02)</a>:</h4>
<p><span class="user-mention silent" data-user-id="119009">eddyb</span> <a href="#narrow/stream/131828-t-compiler/topic/lazy.20norm.20const.20parent.20generics.20hack/near/203951959">said</a>:</p>
<blockquote>
<p>e.g. <span class="user-mention silent" data-user-id="124288">oli</span> may have made some stuff lazy without being behind any feature-gates</p>
</blockquote>
<p><span aria-label="ghost" class="emoji emoji-1f47b" role="img" title="ghost">:ghost:</span></p>



<a name="203951995"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/lazy%20norm%20const%20parent%20generics%20hack/near/203951995" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> eddyb <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/lazy.20norm.20const.20parent.20generics.20hack.html#203951995">(Jul 15 2020 at 13:02)</a>:</h4>
<p>and it might be enough to make these examples work</p>



<a name="203952038"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/lazy%20norm%20const%20parent%20generics%20hack/near/203952038" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> oli <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/lazy.20norm.20const.20parent.20generics.20hack.html#203952038">(Jul 15 2020 at 13:03)</a>:</h4>
<p><span aria-label="shock" class="emoji emoji-1f628" role="img" title="shock">:shock:</span></p>



<a name="203952194"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/lazy%20norm%20const%20parent%20generics%20hack/near/203952194" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> eddyb <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/lazy.20norm.20const.20parent.20generics.20hack.html#203952194">(Jul 15 2020 at 13:04)</a>:</h4>
<p>like do we even try to evaluate constants anymore?</p>



<a name="203952238"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/lazy%20norm%20const%20parent%20generics%20hack/near/203952238" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> oli <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/lazy.20norm.20const.20parent.20generics.20hack.html#203952238">(Jul 15 2020 at 13:04)</a>:</h4>
<p>yes</p>



<a name="203952258"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/lazy%20norm%20const%20parent%20generics%20hack/near/203952258" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> eddyb <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/lazy.20norm.20const.20parent.20generics.20hack.html#203952258">(Jul 15 2020 at 13:05)</a>:</h4>
<p>okay so maybe <code>impl</code> headers changed for whatever reason, and we should try <code>where</code> clauses instead</p>



<a name="203952325"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/lazy%20norm%20const%20parent%20generics%20hack/near/203952325" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/lazy.20norm.20const.20parent.20generics.20hack.html#203952325">(Jul 15 2020 at 13:05)</a>:</h4>
<p>This still breaks as expected</p>
<div class="codehilite"><pre><span></span><code><span class="k">fn</span> <span class="nf">break_me</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="p">()</span><span class="w"></span>
<span class="k">where</span><span class="w"></span>
<span class="w">    </span><span class="p">[</span><span class="kt">u8</span><span class="p">;</span><span class="w"> </span><span class="mi">1</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span><span class="p">]</span>: <span class="nb">From</span><span class="o">&lt;</span><span class="p">[</span><span class="kt">u8</span><span class="p">;</span><span class="w"> </span><span class="mi">1</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span><span class="p">]</span><span class="o">&gt;</span><span class="w"></span>
<span class="p">{}</span><span class="w"></span>
</code></pre></div>



<a name="203952383"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/lazy%20norm%20const%20parent%20generics%20hack/near/203952383" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> eddyb <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/lazy.20norm.20const.20parent.20generics.20hack.html#203952383">(Jul 15 2020 at 13:06)</a>:</h4>
<p>okay so we did something to <code>impl</code>s</p>



<a name="203952406"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/lazy%20norm%20const%20parent%20generics%20hack/near/203952406" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> eddyb <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/lazy.20norm.20const.20parent.20generics.20hack.html#203952406">(Jul 15 2020 at 13:06)</a>:</h4>
<p>may have been Chalk-related</p>



<a name="203952456"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/lazy%20norm%20const%20parent%20generics%20hack/near/203952456" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> eddyb <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/lazy.20norm.20const.20parent.20generics.20hack.html#203952456">(Jul 15 2020 at 13:06)</a>:</h4>
<p><span class="user-mention" data-user-id="216206">@lcnr</span> do you know if we did a crater run with the kind of mode you're testing with locally now?</p>



<a name="203952471"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/lazy%20norm%20const%20parent%20generics%20hack/near/203952471" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> eddyb <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/lazy.20norm.20const.20parent.20generics.20hack.html#203952471">(Jul 15 2020 at 13:07)</a>:</h4>
<p>might be useful to see what breaks :P</p>



<a name="203952483"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/lazy%20norm%20const%20parent%20generics%20hack/near/203952483" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/lazy.20norm.20const.20parent.20generics.20hack.html#203952483">(Jul 15 2020 at 13:07)</a>:</h4>
<p><span class="user-mention silent" data-user-id="119009">eddyb</span> <a href="#narrow/stream/131828-t-compiler/topic/lazy.20norm.20const.20parent.20generics.20hack/near/203952456">said</a>:</p>
<blockquote>
<p><span class="user-mention silent" data-user-id="216206">lcnr</span> do you know if we did a crater run with the kind of mode you're testing with locally now?</p>
</blockquote>
<p>I know and we did not</p>



<a name="203952503"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/lazy%20norm%20const%20parent%20generics%20hack/near/203952503" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> eddyb <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/lazy.20norm.20const.20parent.20generics.20hack.html#203952503">(Jul 15 2020 at 13:07)</a>:</h4>
<p>especially if <code>impl</code>s are fine, which used to be the worst part</p>



<a name="203952521"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/lazy%20norm%20const%20parent%20generics%20hack/near/203952521" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/lazy.20norm.20const.20parent.20generics.20hack.html#203952521">(Jul 15 2020 at 13:07)</a>:</h4>
<p>at least not in the last 3 months</p>



<a name="203952543"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/lazy%20norm%20const%20parent%20generics%20hack/near/203952543" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> eddyb <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/lazy.20norm.20const.20parent.20generics.20hack.html#203952543">(Jul 15 2020 at 13:07)</a>:</h4>
<p>feel free to, I guess :D</p>



<a name="203952552"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/lazy%20norm%20const%20parent%20generics%20hack/near/203952552" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/lazy.20norm.20const.20parent.20generics.20hack.html#203952552">(Jul 15 2020 at 13:07)</a>:</h4>
<p>or wait 4 I think, when did I start contributing <span aria-label="sweat smile" class="emoji emoji-1f605" role="img" title="sweat smile">:sweat_smile:</span></p>



<a name="203952689"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/lazy%20norm%20const%20parent%20generics%20hack/near/203952689" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/lazy.20norm.20const.20parent.20generics.20hack.html#203952689">(Jul 15 2020 at 13:08)</a>:</h4>
<p>Hmm, I am somwhat more intested in what happens if we always use lazy normalization <span aria-label="sparkles" class="emoji emoji-2728" role="img" title="sparkles">:sparkles:</span></p>



<a name="203952754"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/lazy%20norm%20const%20parent%20generics%20hack/near/203952754" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> eddyb <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/lazy.20norm.20const.20parent.20generics.20hack.html#203952754">(Jul 15 2020 at 13:09)</a>:</h4>
<p>I guess both are interesting</p>



<a name="203952856"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/lazy%20norm%20const%20parent%20generics%20hack/near/203952856" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/lazy.20norm.20const.20parent.20generics.20hack.html#203952856">(Jul 15 2020 at 13:10)</a>:</h4>
<p>I know that lazy norm currently ICEs  when dealing with hrtb</p>



<a name="203955137"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/lazy%20norm%20const%20parent%20generics%20hack/near/203955137" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> eddyb <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/lazy.20norm.20const.20parent.20generics.20hack.html#203955137">(Jul 15 2020 at 13:31)</a>:</h4>
<p>kind of funny, because before deferring const eval was brought up, lazy normalization was originally about making associated type normalization work  with HRTBs</p>



<hr><p>Last updated: Aug 07 2021 at 22:04 UTC</p>
</html>